package com.example.lin.generate;

import org.assertj.core.util.Lists;
import org.junit.jupiter.api.Test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @className: TextComparison
 * @description:
 * @author: Lin.Gu
 * @date: 2024/11/15
 */
public class TextComparison {


    public static void main(String[] args) {
        // 终极解决方案
        String regex =   "^(?i)(?!.*(?:GmbH|company)).*$";
        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        // 测试用例
        String[] testCases = {
                "My Business",           // 有效
                "ABC GmbH",              // 无效 - 包含GmbH
                "Book Store",            // 无效 - 包含Store
                "XYZ Company",           // 无效 - 包含Company
                "Coffee Shop",           // 无效 - 包含Shop
                "gmbh enterprise",       // 无效 - 小写gmbh
                "  Super Store  ",       // 无效 - 前后有空格
                "Online marketplace",    // 有效
                "CompanyXYZ",            // 无效 - 包含company
                "gmbh",                  // 无效 - 仅包含gmbh
                "GMBH",                  // 无效 - 大写GMBH
                "myShop",                // 无效 - 包含shop
                "companya",              // 无效 - 包含company
                "store123",              // 无效 - 包含store
                "ashopb",           // 无效 - 包含Shop
                "shopa",           // 无效 - 包含Shop
                "abshop",           // 无效 - 包含Shop
        };


        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }


    @Test
    public void  testContainsShopOrStore(){
        //
        String regex =  "^(?i)(?!.*(?:\\bstore\\b|\\bshop\\b)).*$";

        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        // 测试用例
        String[] testCases = {
                "book shop",
                "clothing store",
                "SHOP",
                "STORE",
                "shopper",
                "bookstore",
                "my shop",
                "store manager",
                "shopping",
                "grocery",
        };


        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }


    @Test
    public void testS() {
        // 仅拦截IOSS的正则表达式
        String regex = "^(?i)(?!.*IOSS(?:[\\s_-]*\\d+|\\w*)|.*\\bIOSS).*$";

        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);

        // 测试用例（包含所有历史失败案例）
        String[] testCases = {
                // 有效案例
                "123 Main Street",           // 有效
                "Apartment 4B",              // 有效
                "Apartment 4B DHL",          // 有效
                "ParcelService",             // 有效（不包含完整关键词）
                "PostalCode 10001",          // 有效
                "Post Office",               // 有效（普通邮局，非邮政信箱）

                // 无效案例（必须全部拦截）
                "PO Box 12345",              // 无效
                "P.O. Box 987",              // 无效
                "Post Office Box 567",       // 无效
                "postfach 987",              // 无效
                "Parcel Shop DHL",           // 无效
                "Parcel   shop   DHL",       // 无效
                "Shipping to PO Box",        // 无效
                "postFACH 567",              // 无效
                "PB 456",                    // 无效
                "P.O.Box 789",               // 无效
                "PoBox 101",                 // 无效
                "Naumannstr.74Parcel shop",   // 无效（关键失败案例）
                "45ParcelshopABC",           // 无效
                "Pbox 123",                  // 无效
                "p.o box 456",               // 无效
                "PostfachABC123",            // 无效
                "Parcel-Shop",               // 无效
                "P.O Box-123",               // 无效
                "Naumannstr.74ioss",                    // 无效
                "post-office box 789",       // 无效
                "Ursrainer Ring 4 IOSS IM2760000742",       // 无效
                "Ursrainer Ring 4 IOSSIM2760000742",       // 无效
                "Ursrainer Ring 4 iossIM2760000742",       // 无效
                "Ursrainer Ring 4 ioss IM2760000742",       // 无效
        };

        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }


    @Test
    public void test() {
        // 正则表达式：
        String regex = "^(1(\\.\\d+)?|([2-9]\\d{0,3}|1\\d{4}|13[0-5]\\d{2}|1360\\d|13610)(\\.0+)?|1\\d{1,3}(\\.\\d+)?|13610(\\.0+)?)$";

        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);
        String[] testCases = {
                // 有效用例（在1-50.8范围内）
                "1",          // 最小值整数
                "1.0",        // 最小值带小数
                "5",          // 中间整数
                "10.5",       // 中间带小数
                "30.0",       // 整数值带.0
                "49.999",     // 接近50的小数
                "50",         // 50整数
                "50.0",       // 50.0
                "50.8",       // 最大值
                "50.7999",    // 小于最大值的小数
                "25.3",       // 中间值带小数

                // 无效用例（超出1-50.8范围）
                "0",          // 小于最小值
                "0.9",        // 小于1的小数
                "50.80001",   // 超过最大值的小数
                "51",         // 超过50的整数
                "100",        // 远大于最大值
                "50.9",       // 超过0.8的小数部分                 // 超长带小数
        };

        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }


    @Test
    public void testBatteryType() {
        // 正则表达式：允许数字、加号和空格
        String regex = "^(PI967SEC2|PI970SEC2|2|8)$";

        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);
        String[] testCases = {
                "PI967SEC2",   // 匹配
                "PI970SEC2",   // 匹配
                "PI967SEC",    // 不匹配
                "PI970SEC3",   // 不匹配
                "PI967SEC2 ",  // 不匹配（包含空格）
                "xPI967SEC2",  // 不匹配（开头有额外字符）
                "PI967SEC2x",  // 不匹配（结尾有额外字符）
                "PI967sec2",   // 不匹配（小写字母）
                "2",   // 不匹配（小写字母）
                "8",   // 不匹配（小写字母）
        };

        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }

    @Test
    public void testNumber() {
        // 正则表达式：校验字符串不能是纯数字
        String regex =  "^(\\d{5}|\\d{5}-\\d{4})$";


        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);
        String[] testCases = {
                "1234567890",  // 有效（10位纯数字）
                "12345-6789",  // 有效（5-4格式）
                "123456789",   // 无效（9位）
                "12345-678",   // 无效（9位）
                "1234-56789",  // 无效（错误分隔）
                "12345678901", // 无效（11位）
                "1234a67890",  // 无效（含字母）
                "12345-678a",  // 无效（含字母）
                "0000000000",  // 有效（10位纯数字）
                "99999-9999",  // 有效（5-4格式）
                "12 4567890",  // 无效（含空格）
                "12345-67890",  // 无效（11位）
                "12345",  // 无效（11位）
                "123",  // 无效（11位）
                "90533",  // 无效（11位）
        };


        // 执行测试
        for (String testCase : testCases) {
            boolean isValid = pattern.matcher(testCase).matches();
            System.out.printf("输入: %-30s 结果: %s%n", testCase, isValid ? "有效" : "无效");
        }
    }


    @Test
    public void testOldList() {
        List<String> oldList = Lists.newArrayList("1");
        List<String> newList = Lists.newArrayList("2");

        System.out.println("开始处理" + oldList.size() + "===" + newList.size());
        for (String str : oldList) {
            if (!newList.contains(str)) {
                System.out.println(str);
            }
        }
        System.out.println("结束处理");
    }


    // 读取邮编文件并生成正则表达式
    private static String generateZipCodeRegex(String filePath) throws Exception {
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String collect = br.lines()
                    .map(line -> line.trim())
                    .collect(Collectors.joining("|"));
            return "^(" + collect + ")\\d{2}$";
        }
    }

    @Test
    public void testZipCodeRegex() throws Exception {
        String regex = generateZipCodeRegex("C:\\Users\\181596\\Desktop\\邮编范围.txt");
        System.out.println(regex);

//        String regex = "\\b\\d{5}\\b";
        String[] testValues = {
                "06069", "08031", "27677"
        };

        Pattern pattern = Pattern.compile(regex);

        for (String value : testValues) {
            boolean isValid = pattern.matcher(value).matches();
            System.out.println(value + " 是否有效: " + isValid);
        }
    }
}
